1/*
2 * Copyright (C) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the 'License');
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an 'AS IS' BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15// @ts-nocheck
16import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index';
17import pasteboard from '@ohos.pasteboard';
18import image from '@ohos.multimedia.image';
19
20describe('PasteBoardJSTest', function () {
21  beforeAll(async function () {
22    console.info('beforeAll');
23  });
24
25  afterAll(async function () {
26    console.info('afterAll');
27  });
28
29  /**
30   * @tc.name      pasteboard_callback_test1
31   * @tc.desc      createPlainTextData test
32   * @tc.type      Function
33   * @tc.require   AR000HEECD
34   */
35  it('pasteboard_callback_test1', 0, async function (done) {
36    const systemPasteboard = pasteboard.getSystemPasteboard();
37    systemPasteboard.clear((err, data) => {
38      if (err) {
39        console.error('f_test1: systemPasteboard.clear callback error:' + err);
40        return;
41      }
42      const textData1 = 'Hello World!';
43      const pasteData = pasteboard.createPlainTextData(textData1);
44      systemPasteboard.setPasteData(pasteData, (err, data) => {
45        if (err) {
46          console.error('f_test1: systemPasteboard.setPasteData callback error:' + err);
47          return;
48        }
49        systemPasteboard.hasPasteData((err, data) => {
50          if (err) {
51            console.error('f_test1: systemPasteboard.hasPasteData callback error:' + err);
52            return;
53          }
54          expect(data).assertEqual(true);
55          systemPasteboard.getPasteData((err, data) => {
56            if (err) {
57              console.error('f_test1: systemPasteboard.getPasteData callback error:' + err);
58              return;
59            }
60            expect(data.getRecordCount()).assertEqual(1);
61            const primaryText1 = data.getPrimaryText();
62            expect(primaryText1).assertEqual(textData1);
63            expect(pasteboard.MAX_RECORD_NUM).assertEqual(512);
64            expect(data.hasMimeType(pasteboard.MIMETYPE_TEXT_PLAIN)).assertEqual(true);
65            expect(data.getPrimaryMimeType()).assertEqual(pasteboard.MIMETYPE_TEXT_PLAIN);
66            done();
67          });
68        });
69      });
70    });
71  });
72
73  /**
74   * @tc.name      pasteboard_callback_test2
75   * @tc.desc      createHtmlData test
76   * @tc.type      Function
77   * @tc.require   AR000HEECD
78   */
79  it('pasteboard_callback_test2', 0, async function (done) {
80    const systemPasteboard = pasteboard.getSystemPasteboard();
81    systemPasteboard.clear((err, data) => {
82      if (err) {
83        console.error('f_test2: systemPasteboard.clear callback error:' + err);
84        return;
85      }
86      const htmlText2 = '<html><head></head><body>Hello World!</body></html>';
87      const pasteData = pasteboard.createHtmlData(htmlText2);
88      systemPasteboard.setPasteData(pasteData, (err, data) => {
89        if (err) {
90          console.error('f_test2: systemPasteboard.setPasteData callback error:' + err);
91          return;
92        }
93        systemPasteboard.hasPasteData((err, data) => {
94          if (err) {
95            console.error('f_test2: systemPasteboard.hasPasteData callback error:' + err);
96            return;
97          }
98          expect(data).assertEqual(true);
99          systemPasteboard.getPasteData((err, data) => {
100            if (err) {
101              console.error('f_test2: systemPasteboard.getPasteData callback error:' + err);
102              return;
103            }
104            expect(data.getRecordCount()).assertEqual(1);
105            const PrimaryHtml2 = data.getPrimaryHtml();
106            console.info('f_test2: PrimaryHtml = ' + PrimaryHtml2);
107            expect(PrimaryHtml2).assertEqual(htmlText2);
108            expect(data.hasMimeType(pasteboard.MIMETYPE_TEXT_HTML)).assertEqual(true);
109            expect(data.getPrimaryMimeType()).assertEqual(pasteboard.MIMETYPE_TEXT_HTML);
110            done();
111          });
112        });
113      });
114    });
115  });
116
117  /**
118   * @tc.name      pasteboard_callback_test3
119   * @tc.desc      测试异步callback调用+createHtmlData,htmlText = ''.
120   * @tc.type      Function
121   * @tc.require   AR000HEECD
122   */
123  it('pasteboard_callback_test3', 0, async function (done) {
124    const systemPasteboard = pasteboard.getSystemPasteboard();
125    systemPasteboard.clear((err, data) => {
126      if (err) {
127        console.error('f_test3: systemPasteboard.clear callback error:' + err);
128        return;
129      }
130      const htmlText3 = '';
131      const pasteData = pasteboard.createHtmlData(htmlText3);
132      systemPasteboard.setPasteData(pasteData, (err, data) => {
133        if (err) {
134          console.error('f_test3: systemPasteboard.setPasteData callback error:' + err);
135          return;
136        }
137        systemPasteboard.hasPasteData((err, data) => {
138          if (err) {
139            console.error('f_test3: systemPasteboard.hasPasteData callback error:' + err);
140            return;
141          }
142          expect(data).assertEqual(true);
143          systemPasteboard.getPasteData((err, data) => {
144            if (err) {
145              console.error('f_test3: systemPasteboard.getPasteData callback error:' + err);
146              return;
147            }
148            expect(data.getRecordCount()).assertEqual(1);
149            const PrimaryHtml3 = data.getPrimaryHtml();
150            console.info('f_test3: PrimaryHtml = ' + PrimaryHtml3);
151            expect(PrimaryHtml3).assertEqual(htmlText3);
152            expect(data.hasMimeType(pasteboard.MIMETYPE_TEXT_HTML)).assertEqual(true);
153            expect(data.getPrimaryMimeType()).assertEqual(pasteboard.MIMETYPE_TEXT_HTML);
154            done();
155          });
156        });
157      });
158    });
159  });
160
161  /**
162   * @tc.name      pasteboard_callback_test4
163   * @tc.desc      createUriData test
164   * @tc.type      Function
165   * @tc.require   AR000HEECD
166   */
167  it('pasteboard_callback_test4', 0, async function (done) {
168    const systemPasteboard = pasteboard.getSystemPasteboard();
169    systemPasteboard.clear((err, data) => {
170      if (err) {
171        console.error('f_test4: systemPasteboard.clear callback error:' + err);
172        return;
173      }
174      const uriText4 = '';
175      const pasteData = pasteboard.createUriData(uriText4);
176      systemPasteboard.setPasteData(pasteData, (err, data) => {
177        if (err) {
178          console.error('f_test4: systemPasteboard.setPasteData callback error:' + err);
179          return;
180        }
181        systemPasteboard.hasPasteData((err, data) => {
182          if (err) {
183            console.error('f_test4: systemPasteboard.hasPasteData callback error:' + err);
184            return;
185          }
186          expect(data).assertEqual(true);
187          systemPasteboard.getPasteData((err, data) => {
188            if (err) {
189              console.error('f_test4: systemPasteboard.getPasteData callback error:' + err);
190              return;
191            }
192            expect(data.getRecordCount()).assertEqual(1);
193            const PrimaryUri4 = data.getPrimaryUri();
194            console.info('f_test4: PrimaryUri = ' + PrimaryUri4);
195            expect(PrimaryUri4).assertEqual(uriText4);
196            expect(data.hasMimeType(pasteboard.MIMETYPE_TEXT_URI)).assertEqual(true);
197            expect(data.getPrimaryMimeType()).assertEqual(pasteboard.MIMETYPE_TEXT_URI);
198            done();
199          });
200        });
201      });
202    });
203  });
204
205  /**
206   * @tc.name      pasteboard_callback_test5
207   * @tc.desc      createWantData test
208   * @tc.type      Function
209   * @tc.require   AR000HEECD
210   */
211  it('pasteboard_callback_test5', 0, async function (done) {
212    const systemPasteboard = pasteboard.getSystemPasteboard();
213    systemPasteboard.clear((err, data) => {
214      if (err) {
215        console.error('f_test5: systemPasteboard.clear callback error:' + err);
216        return;
217      }
218      const want5 = {
219        bundleName: 'com.example.myapplication8',
220        abilityName: 'com.example.myapplication8.MainAbility',
221      };
222      const pasteData = pasteboard.createWantData(want5);
223      systemPasteboard.setPasteData(pasteData, (err, data) => {
224        if (err) {
225          console.error('f_test5: systemPasteboard.setPasteData callback error:' + err);
226          return;
227        }
228        systemPasteboard.hasPasteData((err, data) => {
229          if (err) {
230            console.error('f_test5: systemPasteboard.hasPasteData callback error:' + err);
231            return;
232          }
233          expect(data).assertEqual(true);
234          systemPasteboard.getPasteData((err, data) => {
235            if (err) {
236              console.error('f_test5: systemPasteboard.getPasteData callback error:' + err);
237              return;
238            }
239            expect(data.getRecordCount()).assertEqual(1);
240            const PrimaryWant5 = data.getPrimaryWant();
241            expect(PrimaryWant5.bundleName).assertEqual(want5.bundleName);
242            expect(PrimaryWant5.abilityName).assertEqual(want5.abilityName);
243            expect(data.hasMimeType(pasteboard.MIMETYPE_TEXT_WANT)).assertEqual(true);
244            expect(data.getPrimaryMimeType()).assertEqual(pasteboard.MIMETYPE_TEXT_WANT);
245            done();
246          });
247        });
248      });
249    });
250  });
251
252  /**
253   * @tc.name      pasteboard_callback_test6
254   * @tc.desc      addTextRecord test
255   * @tc.type      Function
256   * @tc.require   AR000HEECD
257   */
258  it('pasteboard_callback_test6', 0, async function (done) {
259    const systemPasteboard = pasteboard.getSystemPasteboard();
260    systemPasteboard.clear((err, data) => {
261      if (err) {
262        console.error('f_test6: systemPasteboard.clear callback error:' + err);
263        return;
264      }
265      const textData6 = 'Hello World!';
266      const pasteData = pasteboard.createPlainTextData(textData6);
267      const textData62 = 'Hello World1';
268      pasteData.addTextRecord(textData62);
269      systemPasteboard.setPasteData(pasteData, (err, data) => {
270        if (err) {
271          console.error('f_test6: systemPasteboard.setPasteData callback error:' + err);
272          return;
273        }
274        systemPasteboard.hasPasteData((err, data) => {
275          if (err) {
276            console.error('f_test6: systemPasteboard.hasPasteData callback error:' + err);
277            return;
278          }
279          expect(data).assertEqual(true);
280          systemPasteboard.getPasteData((err, data) => {
281            if (err) {
282              console.error('f_test6: systemPasteboard.getPasteData callback error:' + err);
283              return;
284            }
285            expect(data.getRecordCount()).assertEqual(2);
286            const PrimaryText6 = data.getPrimaryText();
287            expect(PrimaryText6).assertEqual(textData62);
288            expect(data.hasMimeType(pasteboard.MIMETYPE_TEXT_PLAIN)).assertEqual(true);
289            expect(data.getPrimaryMimeType()).assertEqual(pasteboard.MIMETYPE_TEXT_PLAIN);
290            done();
291          });
292        });
293      });
294    });
295  });
296
297  /**
298   * @tc.name      pasteboard_callback_test7
299   * @tc.desc      addTextRecord test
300   * @tc.type      Function
301   * @tc.require   AR000HEECD
302   */
303  it('pasteboard_callback_test7', 0, async function (done) {
304    const systemPasteboard = pasteboard.getSystemPasteboard();
305    systemPasteboard.clear((err, data) => {
306      if (err) {
307        console.error('f_test7: systemPasteboard.clear callback error:' + err);
308        return;
309      }
310      const textData71 = 'Hello World!';
311      const pasteData = pasteboard.createPlainTextData(textData71);
312      let textData7 = '';
313      for (let i = 1; i < 15; i++) {
314        textData7 = 'Hello World';
315        textData7 = textData7 + i;
316        pasteData.addTextRecord(textData7);
317      }
318      systemPasteboard.setPasteData(pasteData, (err, data) => {
319        if (err) {
320          console.error('f_test7: systemPasteboard.setPasteData callback error:' + err);
321          return;
322        }
323        systemPasteboard.hasPasteData((err, data) => {
324          if (err) {
325            console.error('f_test7: systemPasteboard.hasPasteData callback error:' + err);
326            return;
327          }
328          expect(data).assertEqual(true);
329          systemPasteboard.getPasteData((err, data) => {
330            if (err) {
331              console.error('f_test7: systemPasteboard.getPasteData callback error:' + err);
332              return;
333            }
334            expect(data.getRecordCount()).assertEqual(15);
335            const PrimaryText7 = data.getPrimaryText();
336            expect(data.hasMimeType(pasteboard.MIMETYPE_TEXT_PLAIN)).assertEqual(true);
337            expect(data.getPrimaryMimeType()).assertEqual(pasteboard.MIMETYPE_TEXT_PLAIN);
338            expect(PrimaryText7).assertEqual('Hello World14');
339            done();
340          });
341        });
342      });
343    });
344  });
345
346  /**
347   * @tc.name      pasteboard_callback_test8
348   * @tc.desc      addHtmlRecord+addUriRecord+addWantRecord
349   * @tc.type      Function
350   * @tc.require   AR000HEECD
351   */
352  it('pasteboard_callback_test8', 0, async function (done) {
353    const systemPasteboard = pasteboard.getSystemPasteboard();
354    systemPasteboard.clear((err, data) => {
355      if (err) {
356        console.error('f_test8: systemPasteboard.clear callback error:' + err);
357        return;
358      }
359      const textData8 = 'Hello World!';
360      const pasteData = pasteboard.createPlainTextData(textData8);
361      const htmlText8 = '<html><head></head><body>Hello World!</body></html>';
362      pasteData.addHtmlRecord(htmlText8);
363      const uriText8 = '';
364      pasteData.addUriRecord(uriText8);
365      const want8 = {
366        bundleName: 'com.example.myapplication8',
367        abilityName: 'com.example.myapplication8.MainAbility',
368      };
369      pasteData.addWantRecord(want8);
370      systemPasteboard.setPasteData(pasteData, (err, data) => {
371        if (err) {
372          console.error('f_test8: systemPasteboard.setPasteData callback error:' + err);
373          return;
374        }
375        systemPasteboard.hasPasteData((err, data) => {
376          if (err) {
377            console.error('f_test8: systemPasteboard.hasPasteData callback error:' + err);
378            return;
379          }
380          expect(data).assertEqual(true);
381          systemPasteboard.getPasteData((err, data) => {
382            if (err) {
383              console.error('f_test8: systemPasteboard.getPasteData callback error:' + err);
384              return;
385            }
386            expect(data.getRecordCount()).assertEqual(4);
387            const MimeTypes8 = data.getMimeTypes();
388            expect(MimeTypes8.length).assertEqual(4);
389            const expectedMimeTypes = new Set([pasteboard.MIMETYPE_TEXT_PLAIN, pasteboard.MIMETYPE_TEXT_HTML,
390              pasteboard.MIMETYPE_TEXT_URI, pasteboard.MIMETYPE_TEXT_WANT]);
391            expect(Array.from(MimeTypes8).every(type => expectedMimeTypes.has(type))).assertEqual(true);
392            done();
393          });
394        });
395      });
396    });
397  });
398
399  /**
400   * @tc.name      pasteboard_callback_test9
401   * @tc.desc      addHtmlRecord+addUriRecord+removeRecordAt
402   * @tc.type      Function
403   * @tc.require   AR000HEECD
404   */
405  it('pasteboard_callback_test9', 0, async function (done) {
406    const systemPasteboard = pasteboard.getSystemPasteboard();
407    systemPasteboard.clear((err, data) => {
408      if (err) {
409        console.error('f_test9: systemPasteboard.clear callback error:' + err);
410        return;
411      }
412      const textData9 = 'Hello World!';
413      const pasteData = pasteboard.createPlainTextData(textData9);
414      const htmlText9 = '<html><head></head><body>Hello World!</body></html>';
415      pasteData.addHtmlRecord(htmlText9);
416      const uriText9 = '';
417      pasteData.addUriRecord(uriText9);
418      systemPasteboard.setPasteData(pasteData, (err, data) => {
419        if (err) {
420          console.error('f_test9: systemPasteboard.setPasteData callback error:' + err);
421          return;
422        }
423        systemPasteboard.hasPasteData((err, data) => {
424          if (err) {
425            console.error('f_test9: systemPasteboard.hasPasteData callback error:' + err);
426            return;
427          }
428          expect(data).assertEqual(true);
429          systemPasteboard.getPasteData((err, data) => {
430            if (err) {
431              console.error('f_test9: systemPasteboard.getPasteData callback error:' + err);
432              return;
433            }
434            expect(data.getRecordCount()).assertEqual(3);
435            expect(data.removeRecordAt(0)).assertEqual(true);
436            expect(data.getRecordCount()).assertEqual(2);
437            systemPasteboard.setPasteData(data, (err, newdata) => {
438              if (err) {
439                console.error('f_test9: systemPasteboard.setPasteData callback error:' + err);
440                return;
441              }
442              systemPasteboard.getPasteData((err, data) => {
443                if (err) {
444                  console.error('f_test9: systemPasteboard.getPasteData callback error:' + err);
445                  return;
446                }
447                expect(data.getRecordCount()).assertEqual(2);
448                done();
449              });
450            });
451          });
452        });
453      });
454    });
455  });
456
457  /**
458   * @tc.name      pasteboard_callback_test10
459   * @tc.desc      Add 30 TextRecords
460   * @tc.type      Function
461   * @tc.require   AR000H5GKU
462   */
463  it('pasteboard_callback_test10', 0, async function (done) {
464    const systemPasteboard = pasteboard.getSystemPasteboard();
465    systemPasteboard.clear((err, data) => {
466      if (err) {
467        console.error('f_test10: systemPasteboard.clear callback error:' + err);
468        return;
469      }
470      const textData101 = 'Hello World!';
471      const pasteData = pasteboard.createPlainTextData(textData101);
472      let textData10 = '';
473      for (let i = 1; i < 30; i++) {
474        textData10 = 'Hello World';
475        textData10 = textData10 + i;
476        pasteData.addTextRecord(textData10);
477      }
478      systemPasteboard.setPasteData(pasteData, (err, data) => {
479        if (err) {
480          console.error('f_test10: systemPasteboard.setPasteData callback error:' + err);
481          return;
482        }
483        systemPasteboard.hasPasteData((err, data) => {
484          if (err) {
485            console.error('f_test10: systemPasteboard.hasPasteData callback error:' + err);
486            return;
487          }
488          expect(data).assertEqual(true);
489          systemPasteboard.getPasteData((err, data) => {
490            if (err) {
491              console.error('f_test10: systemPasteboard.getPasteData callback error:' + err);
492              return;
493            }
494            expect(data.getRecordCount()).assertEqual(30);
495            for (let i = 0; i < 30; i++) {
496              expect(data.removeRecordAt(0)).assertEqual(true);
497            }
498            expect(data.getRecordCount()).assertEqual(0);
499            systemPasteboard.setPasteData(data, (err, newdata) => {
500              if (err) {
501                console.error('f_test10: systemPasteboard.setPasteData callback error:' + err);
502                return;
503              }
504              systemPasteboard.getPasteData((err, data) => {
505                if (err) {
506                  console.error('f_test10: systemPasteboard.getPasteData callback error:' + err);
507                  return;
508                }
509                expect(data.getRecordCount() == 0).assertEqual(true);
510                done();
511              });
512            });
513          });
514        });
515      });
516    });
517  });
518
519  /**
520   * @tc.name      pasteboard_callback_test11
521   * @tc.desc      Replcae textRecord
522   * @tc.type      Function
523   * @tc.require   AR000H5GKU
524   */
525  it('pasteboard_callback_test11', 0, async function (done) {
526    const systemPasteboard = pasteboard.getSystemPasteboard();
527    systemPasteboard.clear((err, data) => {
528      if (err) {
529        console.error('f_test11: systemPasteboard.clear callback error:' + err);
530        return;
531      }
532      const textData11 = 'Hello World!';
533      const pasteData = pasteboard.createPlainTextData(textData11);
534      systemPasteboard.setPasteData(pasteData, (err, data) => {
535        if (err) {
536          console.error('f_test11: systemPasteboard.setPasteData callback error:' + err);
537          return;
538        }
539        systemPasteboard.hasPasteData((err, data) => {
540          if (err) {
541            console.error('f_test11: systemPasteboard.hasPasteData callback error:' + err);
542            return;
543          }
544          expect(data).assertEqual(true);
545          systemPasteboard.getPasteData((err, data) => {
546            if (err) {
547              console.error('f_test11: systemPasteboard.getPasteData callback error:' + err);
548              return;
549            }
550            expect(data.getRecordCount()).assertEqual(1);
551            const textData111 = 'Hello World1';
552            const pasteDataRecord11 = pasteboard.createPlainTextRecord(textData111);
553            const replace11 = data.replaceRecordAt(0, pasteDataRecord11);
554            expect(replace11).assertEqual(true);
555            const primaryText11 = data.getPrimaryText();
556            expect(primaryText11).assertEqual(textData111);
557            done();
558          });
559        });
560      });
561    });
562  });
563
564  /**
565   * @tc.name      pasteboard_callback_test12
566   * @tc.desc      Replcae htmlRecord
567   * @tc.type      Function
568   * @tc.require   AR000H5GKU
569   */
570  it('pasteboard_callback_test12', 0, async function (done) {
571    const systemPasteboard = pasteboard.getSystemPasteboard();
572    systemPasteboard.clear((err, data) => {
573      if (err) {
574        console.error('f_test12: systemPasteboard.clear callback error:' + err);
575        return;
576      }
577      const htmlText12 = '<html><head></head><body>Hello World!</body></html>';
578      const pasteData = pasteboard.createHtmlData(htmlText12);
579      systemPasteboard.setPasteData(pasteData, (err, data) => {
580        if (err) {
581          console.error('f_test12: systemPasteboard.setPasteData callback error:' + err);
582          return;
583        }
584        systemPasteboard.hasPasteData((err, data) => {
585          if (err) {
586            console.error('f_test12: systemPasteboard.hasPasteData callback error:' + err);
587            return;
588          }
589          expect(data).assertEqual(true);
590          systemPasteboard.getPasteData((err, data) => {
591            if (err) {
592              console.error('f_test12: systemPasteboard.getPasteData callback error:' + err);
593              return;
594            }
595            expect(data.getRecordCount()).assertEqual(1);
596            const htmlText121 = '<html><head></head><body>Hello World 1</body></html>';
597            const pasteDataRecord12 = pasteboard.createHtmlTextRecord(htmlText121);
598            const replace12 = data.replaceRecordAt(0, pasteDataRecord12);
599            expect(replace12).assertEqual(true);
600            expect(data.getRecordCount()).assertEqual(1);
601            const primaryHtml12 = data.getPrimaryHtml();
602            expect(primaryHtml12).assertEqual(htmlText121);
603            done();
604          });
605        });
606      });
607    });
608  });
609
610  /**
611   * @tc.name      pasteboard_callback_test13
612   * @tc.desc      Replcae wantRecord
613   * @tc.type      Function
614   * @tc.require   AR000H5GKU
615   */
616  it('pasteboard_callback_test13', 0, async function (done) {
617    const systemPasteboard = pasteboard.getSystemPasteboard();
618    systemPasteboard.clear((err, data) => {
619      if (err) {
620        console.error('f_test13: systemPasteboard.clear callback error:' + err);
621        return;
622      }
623      const wantText13 = {
624        bundleName: 'com.example.myapplication3',
625        abilityName: 'com.example.myapplication3.MainAbility',
626      };
627      const pasteData = pasteboard.createData(pasteboard.MIMETYPE_TEXT_WANT, wantText13);
628      systemPasteboard.setPasteData(pasteData, (err, data) => {
629        if (err) {
630          console.error('f_test13: systemPasteboard.setPasteData callback error:' + err);
631          return;
632        }
633        systemPasteboard.hasPasteData((err, data) => {
634          if (err) {
635            console.error('f_test13: systemPasteboard.hasPasteData callback error:' + err);
636            return;
637          }
638          expect(data).assertEqual(true);
639          systemPasteboard.getPasteData((err, data) => {
640            if (err) {
641              console.error('f_test13: systemPasteboard.getPasteData callback error:' + err);
642              return;
643            }
644            expect(data.getRecordCount()).assertEqual(1);
645            const getWantText13 = {
646              bundleName: 'com.example.myapplication30',
647              abilityName: 'com.example.myapplication30.MainAbility',
648            };
649            const pasteDataRecord13 = pasteboard.createRecord(pasteboard.MIMETYPE_TEXT_WANT, getWantText13);
650            const replace13 = data.replaceRecordAt(0, pasteDataRecord13);
651            expect(replace13).assertEqual(true);
652            const primaryWant13 = data.getPrimaryWant();
653            expect(data.hasMimeType(pasteboard.MIMETYPE_TEXT_WANT)).assertEqual(true);
654            expect(primaryWant13.bundleName).assertEqual(getWantText13.bundleName);
655            expect(primaryWant13.abilityName).assertEqual(getWantText13.abilityName);
656            done();
657          });
658        });
659      });
660    });
661  });
662
663  /**
664   * @tc.name      pasteboard_callback_test14
665   * @tc.desc      get pasteData after clear wantData
666   * @tc.type      Function
667   * @tc.require   AR000H5GKU
668   */
669  it('pasteboard_callback_test14', 0, async function (done) {
670    const systemPasteboard = pasteboard.getSystemPasteboard();
671    systemPasteboard.clear((err, data) => {
672      if (err) {
673        console.error('f_test14: systemPasteboard.clear callback error:' + err);
674        return;
675      }
676      const wantText14 = {
677        bundleName: 'com.example.myapplication3',
678        abilityName: 'com.example.myapplication3.MainAbility',
679      };
680      const pasteData = pasteboard.createWantData(wantText14);
681      systemPasteboard.setPasteData(pasteData, (err, data) => {
682        if (err) {
683          console.error('f_test14: systemPasteboard.setPasteData callback error:' + err);
684          return;
685        }
686        systemPasteboard.hasPasteData((err, data) => {
687          if (err) {
688            console.error('f_test14: systemPasteboard.hasPasteData callback error:' + err);
689            return;
690          }
691          expect(data).assertEqual(true);
692          systemPasteboard.getPasteData((err, data) => {
693            if (err) {
694              console.error('f_test14: systemPasteboard.getPasteData callback error:' + err);
695              return;
696            }
697            expect(data.getRecordCount()).assertEqual(1);
698            systemPasteboard.clear((err, data) => {
699              if (err) {
700                console.error('f_test14: systemPasteboard.clear callback error:' + err);
701                return;
702              }
703              systemPasteboard.getPasteData((err, data) => {
704                if (err) {
705                  console.error('f_test14: systemPasteboard.getPasteData callback error:' + err);
706                  return;
707                }
708                expect(data.getRecordCount()).assertEqual(0);
709                done();
710              });
711            });
712          });
713        });
714      });
715    });
716  });
717
718  /**
719   * @tc.name      pasteboard_callback_test15
720   * @tc.desc      getProperty and setProperty test
721   * @tc.require   AR000H5GKU
722   */
723  it('pasteboard_callback_test15', 0, async function (done) {
724    const systemPasteboard = pasteboard.getSystemPasteboard();
725    systemPasteboard.clear((err, data) => {
726      if (err) {
727        console.error('f_test15: systemPasteboard.clear callback error:' + err);
728        return;
729      }
730      const textData15 = 'Hello World!';
731      const pasteData = pasteboard.createPlainTextData(textData15);
732      systemPasteboard.setPasteData(pasteData, (err, data) => {
733        if (err) {
734          console.error('f_test15: systemPasteboard.setPasteData callback error:' + err);
735          return;
736        }
737        systemPasteboard.hasPasteData((err, data) => {
738          if (err) {
739            console.error('f_test15: systemPasteboard.hasPasteData callback error:' + err);
740            return;
741          }
742          expect(data).assertEqual(true);
743          systemPasteboard.getPasteData((err, data) => {
744            if (err) {
745              console.error('f_test15: systemPasteboard.getPasteData callback error:' + err);
746              return;
747            }
748            expect(data.getRecordCount()).assertEqual(1);
749            const pasteDataProperty15 = data.getProperty();
750            expect(pasteDataProperty15.shareOption).assertEqual(pasteboard.ShareOption.CrossDevice);
751            pasteDataProperty15.shareOption = pasteboard.ShareOption.InApp;
752            data.setProperty(pasteDataProperty15);
753            const getPasteDataProperty15 = data.getProperty();
754            expect(getPasteDataProperty15.shareOption).assertEqual(pasteboard.ShareOption.InApp);
755            done();
756          });
757        });
758      });
759    });
760  });
761
762  /**
763   * @tc.name      pasteboard_callback_test16
764   * @tc.desc      on test
765   * @tc.type      Function
766   * @tc.require   AR000H5GKU
767   */
768  it('pasteboard_callback_test16', 0, async function (done) {
769    const systemPasteboard = pasteboard.getSystemPasteboard();
770    systemPasteboard.clear((err, data) => {
771      if (err) {
772        console.error('f_test16: systemPasteboard.clear callback error:' + err);
773        return;
774      }
775      systemPasteboard.on('update', contentChanges);
776      const textData16 = 'Hello World!';
777      const pasteData = pasteboard.createPlainTextData(textData16);
778      systemPasteboard.setPasteData(pasteData, (err, data) => {
779        if (err) {
780          console.error('f_test16: systemPasteboard.setPasteData callback error:' + err);
781          return;
782        }
783        systemPasteboard.hasPasteData((err, data) => {
784          if (err) {
785            console.error('f_test16: systemPasteboard.hasPasteData callback error:' + err);
786            return;
787          }
788          expect(data === true).assertEqual(true);
789          systemPasteboard.getPasteData((err, data) => {
790            if (err) {
791              console.error('f_test16: systemPasteboard.getPasteData callback error:' + err);
792              return;
793            }
794            expect(data.getRecordCount() == 1).assertEqual(true);
795            expect(data.removeRecordAt(0)).assertEqual(true);
796            expect(data.getRecordCount() == 0).assertEqual(true);
797            done();
798          });
799        });
800      });
801    });
802  });
803
804  /**
805   * @tc.name      pasteboard_callback_test17
806   * @tc.desc      off test
807   * @tc.type      Function
808   * @tc.require   AR000H5GKU
809   */
810  it('pasteboard_callback_test17', 0, async function (done) {
811    const systemPasteboard = pasteboard.getSystemPasteboard();
812    systemPasteboard.clear((err, data) => {
813      if (err) {
814        console.error('f_test17: systemPasteboard.clear callback error:' + err);
815        return;
816      }
817      systemPasteboard.off('update', contentChanges);
818      const textData17 = 'Hello World!';
819      const pasteData = pasteboard.createPlainTextData(textData17);
820      systemPasteboard.setPasteData(pasteData, (err, data) => {
821        if (err) {
822          console.error('f_test17: systemPasteboard.setPasteData callback error:' + err);
823          return;
824        }
825        systemPasteboard.hasPasteData((err, data) => {
826          if (err) {
827            console.error('f_test17: systemPasteboard.hasPasteData callback error:' + err);
828            return;
829          }
830          expect(data).assertEqual(true);
831          systemPasteboard.getPasteData((err, data) => {
832            if (err) {
833              console.error('f_test17: systemPasteboard.getPasteData callback error:' + err);
834              return;
835            }
836            expect(data.getRecordCount()).assertEqual(1);
837            expect(data.removeRecordAt(0)).assertEqual(true);
838            expect(data.getRecordCount()).assertEqual(0);
839            done();
840          });
841        });
842      });
843    });
844  });
845
846  /**
847   * @tc.name      pasteboard_callback_test18
848   * @tc.desc      createRecord test
849   * @tc.type      Function
850   * @tc.require   AR000H5GKU
851   */
852  it('pasteboard_callback_test18', 0, async function (done) {
853    const systemPasteboard = pasteboard.getSystemPasteboard();
854    systemPasteboard.clear().then(() => {
855      const buffer18 = new ArrayBuffer(128);
856      const opt18 = {
857        size: { height: 5, width: 5 },
858        pixelFormat: 3,
859        editable: true,
860        alphaType: 1,
861        scaleMode: 1,
862      };
863      const pasteData = pasteboard.createHtmlData('application/xml');
864      image.createPixelMap(buffer18, opt18).then((pixelMap) => {
865        expect(pixelMap.getPixelBytesNumber()).assertEqual(100);
866        const pixelMapRecord18 = pasteboard.createRecord(pasteboard.MIMETYPE_PIXELMAP, pixelMap);
867        pasteData.addRecord(pixelMapRecord18);
868        systemPasteboard.setPasteData(pasteData).then(() => {
869          systemPasteboard.hasPasteData().then((data) => {
870            expect(data).assertEqual(true);
871            systemPasteboard.getPasteData().then((newPasteData) => {
872              const recordCount18 = newPasteData.getRecordCount();
873              expect(recordCount18).assertEqual(2);
874              const newPixelMap18 = newPasteData.getPrimaryPixelMap();
875              const PixelMapBytesNumber18 = newPixelMap18.getPixelBytesNumber();
876              expect(PixelMapBytesNumber18).assertEqual(100);
877              const newHtmlData18 = newPasteData.getRecordAt(1);
878              expect(newHtmlData18.htmlText).assertEqual('application/xml');
879              newPixelMap18.getImageInfo().then((imageInfo) => {
880                expect(imageInfo.size.height === 5 && imageInfo.size.width === 5).assertEqual(true);
881                done();
882              });
883            });
884          });
885        });
886      });
887    });
888  });
889
890  /**
891   * @tc.name      pasteboard_callback_test19
892   * @tc.desc      Add plainText、htmlText、uriText record
893   * @tc.type      Function
894   * @tc.require   AR000H5GKU
895   */
896  it('pasteboard_callback_test19', 0, async function (done) {
897    const systemPasteboard = pasteboard.getSystemPasteboard();
898    systemPasteboard.clear((err, data) => {
899      if (err) {
900        console.error('f_test19: systemPasteboard.clear callback error:' + err);
901        return;
902      }
903      const textData191 = 'Hello World0';
904      const pasteData = pasteboard.createPlainTextData(textData191);
905      let textData19 = '';
906      for (let i = 1; i < 5; i++) {
907        textData19 = 'Hello World';
908        textData19 = textData19 + i;
909        pasteData.addTextRecord(textData19);
910      }
911      let htmlText19 = '';
912      for (let i = 0; i < 5; i++) {
913        htmlText19 = '<html><head></head><body>Hello World!</body></html>';
914        htmlText19 = htmlText19 + i;
915        pasteData.addHtmlRecord(htmlText19);
916      }
917      let uriText19 = '';
918      for (let i = 0; i < 5; i++) {
919        uriText19 = 'https://www.baidu.com/';
920        uriText19 = uriText19 + i;
921        pasteData.addUriRecord(uriText19);
922      }
923      systemPasteboard.setPasteData(pasteData, (err, data) => {
924        if (err) {
925          console.error('f_test19: systemPasteboard.setPasteData callback error:' + err);
926          return;
927        }
928        systemPasteboard.hasPasteData((err, data) => {
929          if (err) {
930            console.error('f_test19: systemPasteboard.hasPasteData callback error:' + err);
931            return;
932          }
933          expect(data).assertEqual(true);
934          systemPasteboard.getPasteData(async (err, data) => {
935            if (err) {
936              console.error('f_test19: systemPasteboard.getPasteData callback error:' + err);
937              return;
938            }
939            expect(data.getRecordCount()).assertEqual(15);
940            await systemPasteboard.clear();
941            let newData19 = await systemPasteboard.getPasteData();
942            expect(newData19.getRecordCount()).assertEqual(0);
943            done();
944          });
945        });
946      });
947    });
948  });
949
950  /**
951   * @tc.name      pasteboard_callback_test20
952   * @tc.desc      convertToText test
953   * @tc.type      Function
954   * @tc.require   AR000H5GKU
955   */
956  it('pasteboard_callback_test20', 0, async function (done) {
957    const systemPasteboard = pasteboard.getSystemPasteboard();
958    systemPasteboard.clear((err, data) => {
959      if (err) {
960        console.error('f_test20: systemPasteboard.clear callback error:' + err);
961        return;
962      }
963      const textData20 = 'Hello World!';
964      const pasteData = pasteboard.createPlainTextData(textData20);
965      systemPasteboard.setPasteData(pasteData, (err, data) => {
966        if (err) {
967          console.error('f_test20: systemPasteboard.setPasteData callback error:' + err);
968          return;
969        }
970        systemPasteboard.hasPasteData((err, data) => {
971          if (err) {
972            console.error('f_test20: systemPasteboard.hasPasteData callback error:' + err);
973            return;
974          }
975          expect(data).assertEqual(true);
976          systemPasteboard.getPasteData(async (err, data) => {
977            if (err) {
978              console.error('f_test20: systemPasteboard.getPasteData callback error:' + err);
979              return;
980            }
981            expect(data.getRecordCount()).assertEqual(1);
982            const dataRecord20 = data.getRecordAt(0);
983            const text = await dataRecord20.convertToText();
984            expect(text).assertEqual(textData20);
985            done();
986          });
987        });
988      });
989    });
990  });
991
992  /**
993   * @tc.name      pasteboard_callback_test21
994   * @tc.desc      convertToText test
995   * @tc.type      Function
996   * @tc.require   AR000H5GKU
997   */
998  it('pasteboard_callback_test21', 0, async function (done) {
999    const systemPasteboard = pasteboard.getSystemPasteboard();
1000    systemPasteboard.clear((err, data) => {
1001      if (err) {
1002        console.error('f_test21: systemPasteboard.clear callback error:' + err);
1003        return;
1004      }
1005      const textData21 = 'Hello World!';
1006      const pasteData = pasteboard.createPlainTextData(textData21);
1007      systemPasteboard.setPasteData(pasteData, (err, data) => {
1008        if (err) {
1009          console.error('f_test21: systemPasteboard.setPasteData callback error:' + err);
1010          return;
1011        }
1012        systemPasteboard.hasPasteData((err, data) => {
1013          if (err) {
1014            console.error('f_test21: systemPasteboard.hasPasteData callback error:' + err);
1015            return;
1016          }
1017          expect(data).assertEqual(true);
1018          systemPasteboard.getPasteData((err, data) => {
1019            if (err) {
1020              console.error('f_test21: systemPasteboard.getPasteData callback error:' + err);
1021              return;
1022            }
1023            expect(data.getRecordCount()).assertEqual(1);
1024            const dataRecord21 = data.getRecordAt(0);
1025            dataRecord21.convertToText((err, data) => {
1026              if (err) {
1027                console.error('f_test21: PasteDataRecord.convertToText callback error:' + err);
1028                return;
1029              }
1030              expect(data).assertEqual(textData21);
1031              done();
1032            });
1033          });
1034        });
1035      });
1036    });
1037  });
1038
1039  /**
1040   * @tc.name      pasteboard_callback_test22
1041   * @tc.desc      convertToText test
1042   * @tc.type      Function
1043   * @tc.require   AR000H5GKU
1044   */
1045  it('pasteboard_callback_test22', 0, async function (done) {
1046    const systemPasteboard = pasteboard.getSystemPasteboard();
1047    systemPasteboard.clear((err, data) => {
1048      if (err) {
1049        console.error('f_test22: systemPasteboard.clear callback error:' + err);
1050        return;
1051      }
1052      const textData22 = 'Hello 中国!@#$%^&*()_+{}\\?.';
1053      const pasteData = pasteboard.createPlainTextData(textData22);
1054      systemPasteboard.setPasteData(pasteData, (err, data) => {
1055        if (err) {
1056          console.error('f_test22: systemPasteboard.setPasteData callback error:' + err);
1057          return;
1058        }
1059        systemPasteboard.hasPasteData((err, data) => {
1060          if (err) {
1061            console.error('f_test22: systemPasteboard.hasPasteData callback error:' + err);
1062            return;
1063          }
1064          expect(data).assertEqual(true);
1065          systemPasteboard.getPasteData(async (err, data) => {
1066            if (err) {
1067              console.error('f_test22: systemPasteboard.getPasteData callback error:' + err);
1068              return;
1069            }
1070            expect(data.getRecordCount()).assertEqual(1);
1071            const dataRecord22 = data.getRecordAt(0);
1072            const text = await dataRecord22.convertToText();
1073            expect(text).assertEqual(textData22);
1074            done();
1075          });
1076        });
1077      });
1078    });
1079  });
1080
1081  /**
1082   * @tc.name      pasteboard_callback_test23
1083   * @tc.desc      convertToText test
1084   * @tc.type      Function
1085   * @tc.require   AR000H5GKU
1086   */
1087  it('pasteboard_callback_test23', 0, async function (done) {
1088    const systemPasteboard = pasteboard.getSystemPasteboard();
1089    systemPasteboard.clear((err, data) => {
1090      if (err) {
1091        console.error('f_test23: systemPasteboard.clear callback error:' + err);
1092        return;
1093      }
1094      const uriText23 = 'https://www.baidu.com/';
1095      const pasteData = pasteboard.createUriData(uriText23);
1096      systemPasteboard.setPasteData(pasteData, (err, data) => {
1097        if (err) {
1098          console.error('f_test23: systemPasteboard.setPasteData callback error:' + err);
1099          return;
1100        }
1101        systemPasteboard.hasPasteData((err, data) => {
1102          if (err) {
1103            console.error('f_test23: systemPasteboard.hasPasteData callback error:' + err);
1104            return;
1105          }
1106          expect(data).assertEqual(true);
1107          systemPasteboard.getPasteData(async (err, data) => {
1108            if (err) {
1109              console.error('f_test23: systemPasteboard.getPasteData callback error:' + err);
1110              return;
1111            }
1112            expect(data.getRecordCount()).assertEqual(1);
1113            const dataRecord23 = data.getRecordAt(0);
1114            const text = await dataRecord23.convertToText();
1115            expect(text).assertEqual(uriText23);
1116            done();
1117          });
1118        });
1119      });
1120    });
1121  });
1122
1123  /**
1124   *  The callback function is used for pasteboard content changes
1125   */
1126  function contentChanges() {
1127    console.info('#EVENT: The content is changed in the pasteboard');
1128  }
1129});
1130